home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / msdos / raytrace / pov / gen / bstone / borlandc / bstone_l.c next >
Encoding:
C/C++ Source or Header  |  1994-03-21  |  8.5 KB  |  279 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "t_lex.h"
  5. #include "t_cio.h"
  6. #include "bstone_m.h"
  7. #include "bstone_y.h"
  8.  
  9.  
  10. int yylex(void)
  11. {
  12.  double dd; int i,n,c,n1,n2;
  13.  T_NODE *tnode;
  14.  char msg[]={"Parsing command line"};
  15.  char *s;
  16.  
  17.  if(transl_flag==1)
  18.    {
  19.     lex=t_lex(NULL,NO_FORCE);
  20.     if(lex==(LEX *)NULL) return(EOF);
  21.     switch(lex->typ)
  22.       {
  23.        case EOLX:
  24.        case EOLN:   return(EOF);
  25.        case END:    cline[clinep++]=TOKENVAL(END);
  26.             return(Y_END);
  27.        case REM:    cline[clinep++]=TOKENVAL(REM);
  28.             return(Y_REM);
  29.        case GOTO:   cline[clinep++]=TOKENVAL(GOTO);
  30.             return(Y_GOTO);
  31.        case TRACE:  cline[clinep++]=TOKENVAL(TRACE);
  32.             return(Y_TRACE);
  33.        case LET:    return(Y_LET);
  34.        case PRINT:  cline[clinep++]=TOKENVAL(PRINT);
  35.             return(Y_PRINT);
  36.        case LIST:   cline[clinep++]=TOKENVAL(LIST);
  37.             return(Y_LIST);
  38.        case ABS:    cline[clinep++]=TOKENVAL(ABS);
  39.             return(Y_ABS);
  40.        case LOAD:   cline[clinep++]=TOKENVAL(LOAD);
  41.             return(Y_LOAD);
  42.        case SAVE:   cline[clinep++]=TOKENVAL(SAVE);
  43.             return(Y_SAVE);
  44.        case IF:     cline[clinep++]=TOKENVAL(IF);
  45.             return(Y_IF);
  46.        case THEN:   cline[clinep++]=TOKENVAL(THEN);
  47.             return(Y_THEN);
  48.        case STOP:   cline[clinep++]=TOKENVAL(STOP);
  49.             return(Y_STOP);
  50.        case CONT:   cline[clinep++]=TOKENVAL(CONT);
  51.             return(Y_CONT);
  52.        case GOSUB:  cline[clinep++]=TOKENVAL(GOSUB);
  53.             return(Y_GOSUB);
  54.        case RETURN: cline[clinep++]=TOKENVAL(RETURN);
  55.             return(Y_RETURN);
  56.        case DELETE: cline[clinep++]=TOKENVAL(DELETE);
  57.             return(Y_DELETE);
  58.        case DIM:    cline[clinep++]=TOKENVAL(DIM);
  59.             return(Y_DIM);
  60.        case FOR:    cline[clinep++]=TOKENVAL(FOR);
  61.             return(Y_FOR);
  62.        case TO:     cline[clinep++]=TOKENVAL(TO);
  63.             return(Y_TO);
  64.        case STEP:   cline[clinep++]=TOKENVAL(STEP);
  65.             return(Y_STEP);
  66.        case NEXT:   cline[clinep++]=TOKENVAL(NEXT);
  67.             return(Y_NEXT);
  68.        case NEW:    cline[clinep++]=TOKENVAL(NEW);
  69.             return(Y_NEW);
  70.        case RUN:    cline[clinep++]=TOKENVAL(RUN);
  71.             return(Y_RUN);
  72.        case RND:    cline[clinep++]=TOKENVAL(RND);
  73.             return(Y_RND);
  74.        case FOPEN:  cline[clinep++]=TOKENVAL(FOPEN);
  75.             return(Y_FOPEN);
  76.        case FPRINT: cline[clinep++]=TOKENVAL(FPRINT);
  77.             return(Y_FPRINT);
  78.        case V0:     cline[clinep++]=TOKENVAL(V0);
  79.             return(Y_V0);
  80.        case VX:     cline[clinep++]=TOKENVAL(VX);
  81.             return(Y_VX);
  82.        case VY:     cline[clinep++]=TOKENVAL(VY);
  83.             return(Y_VY);
  84.        case VZ:     cline[clinep++]=TOKENVAL(VZ);
  85.             return(Y_VZ);
  86.        case PLANE:  cline[clinep++]=TOKENVAL(PLANE);
  87.             return(Y_PLANE);
  88.        case BIT:    cline[clinep++]=TOKENVAL(BIT);
  89.             return(Y_BIT);
  90.        case BOUND:  cline[clinep++]=TOKENVAL(BOUND);
  91.             return(Y_BOUND);
  92.        case TEX:    cline[clinep++]=TOKENVAL(TEX);
  93.             return(Y_TEX);
  94.        case TRANSFORM:
  95.             cline[clinep++]=TOKENVAL(TRANSFORM);
  96.             return(Y_TRANSFORM);
  97.  
  98.        /* functions; permitted are:                                     */
  99.        /* scalar=f(scalar); scalar=f(scalar,scalar);                    */
  100.        /* obj=f(obj_lst); obj=f(obj,vector)                             */
  101.        /* obj=f#(obj,vector);                                           */
  102.        /* vector=f(vector,vector); handle other f. separately !         */
  103.        case SIN:   case COS:   case TAN:
  104.        case ASIN:  case ACOS:  case ATAN:
  105.        case POW:   case EXP:   case LOG:
  106.        case SQRT:  case ROT:   case SCA:
  107.        case SCALE: case ROTATE:case TRANSLATE:
  108.        case CTDS:  case ADDOBJ:
  109.        case UNION: case SECT:  case DIFF:
  110.        case SQR:   case PER:
  111.             fkt_id=lex->typ;
  112.             cline[clinep++]=TOKENVAL(B_FKT);
  113.             cline[clinep++]=TOKENVAL(fkt_id);
  114.             return(Y_FKT);
  115.  
  116.        case PI:   dd=M_PI; n=1; n1=B_NUM; n2=Y_NUM;
  117.           sprintf(tmp_line,"_PI");
  118.           if((tnode=t_symtable(tmp_line))==(T_NODE *)NULL)
  119.             t_error(msg,-1);
  120.           goto la_val;
  121.        case ZAHL: dd=(double)(lex->wert.n.i);
  122.           lex->wert.n.r=dd;
  123.        case REAL: dd=lex->wert.n.r;
  124.           sprintf(tmp_line,"_%.8G",dd);
  125.           if((tnode=t_symtable(tmp_line))==(T_NODE *)NULL)
  126.             t_error(msg,-1);
  127.           n=1; n1=B_NUM; n2=Y_NUM;
  128.           goto la_val;
  129.        case BEZEICHNER:
  130.           if((tnode=t_symfind(lex->wert.n.i))==(T_NODE *)NULL)
  131.             t_error(msg,-1);
  132.           dd=0; n=1; n1=B_VAL; n2=Y_VAL;
  133.           goto la_val;
  134.        case BEZ_VEC:
  135.           if((tnode=t_symfind(lex->wert.n.i))==(T_NODE *)NULL)
  136.             t_error(msg,-1);
  137.           dd=0; n=3; n1=B_VEC; n2=Y_VEC;
  138.           goto la_val;
  139.  
  140.        la_val:    if(tnode->p==(void *)NULL)
  141.             {
  142.              if((tnode->p=malloc(n*sizeof(double)))
  143.              ==(void *)NULL) t_error(msg,1);
  144.              for(i=0; i<n; i++) *((double *)(tnode->p)+i)=dd;
  145.              tnode->c=n1;
  146.             }
  147.           n=tnode->n;
  148.           cline[clinep++]=TOKENVAL(n1);
  149.           if((long)abs(n)>0XFFFFL) t_error(msg,3);
  150.           sprintf(cline+clinep,"%04.4X",(unsigned short)n); clinep+=4;
  151.           yylval.t=tnode;
  152.           return(n2);
  153.  
  154.        case BEZ_OBJ:
  155.           if((tnode=t_symfind(lex->wert.n.i))==(T_NODE *)NULL)
  156.             t_error(msg,-1);
  157.           if(tnode->p==(void *)NULL)
  158.             {
  159.              tnode->p=(void *)new_obj();
  160.              tnode->c=B_OBJ;
  161.             }
  162.           n=tnode->n;
  163.           cline[clinep++]=TOKENVAL(B_OBJ);
  164.           if((long)abs(n)>0XFFFFL) t_error(msg,3);
  165.           sprintf(cline+clinep,"%04.4X",(unsigned short)n); clinep+=4;
  166.           yylval.p=tnode->p;
  167.           return(Y_OBJ);
  168.  
  169.        case '\"': n=1; tmp_line[0]='\"';
  170.           do
  171.             {
  172.              lex=t_lex(NULL,LEX_RCHAR);
  173.              c=lex->wert.n.i;
  174.              if((lex->typ==EOLX)||((c=='\n')&&(lex->typ!='\\'))||(n>=LSIZE))
  175.             { yyerror("non-terminated string"); return(EOF); }
  176.              if(lex->typ=='\\')            /* special char */
  177.             switch(c)
  178.               {
  179.                case '\n': break;
  180.                case 'n':  tmp_line[n++]='\n'; break;
  181.                case 't':  tmp_line[n++]='\t'; break;
  182.                default:   tmp_line[n++]=c; break;
  183.               }
  184.              else tmp_line[n++]=(char)c;
  185.             }
  186.           while(c!='\"');
  187.           tmp_line[n-1]=(char)0;
  188.           if((tnode=t_symtable(tmp_line))==(T_NODE *)NULL)
  189.             t_error(msg,-1);
  190.           n=tnode->n;
  191.           cline[clinep++]=TOKENVAL(B_STR);
  192.           if((long)abs(n)>0XFFFFL) t_error(msg,3);
  193.           sprintf(cline+clinep,"%04.4X",(unsigned short)n); clinep+=4;
  194.           tnode->c=B_STR;
  195.           yylval.t=tnode;
  196.                   return(Y_STR);
  197.  
  198.        default:   if(lex->typ<256) cline[clinep++]=(char)(lex->typ);
  199.           return(lex->typ);
  200.  
  201.       } /* switch */
  202.    } /* if transl_flag */
  203.  else
  204.    {
  205.     if(clines==(char *)NULL) return(EOF);
  206.     c=(unsigned char)*(clines+(clinep++));
  207.     if(c>=128)
  208.       switch(VALTOKEN(c))
  209.     {
  210.      case END:    return(Y_END);
  211.      case REM:    return(Y_REM);
  212.      case GOTO:   return(Y_GOTO);
  213.      case TRACE:  return(Y_TRACE);
  214.      case LET:    return(Y_LET);
  215.      case PRINT:  return(Y_PRINT);
  216.      case LIST:   return(Y_LIST);
  217.      case ABS:    return(Y_ABS);
  218.      case LOAD:   return(Y_LOAD);
  219.      case SAVE:   return(Y_SAVE);
  220.      case IF:     return(Y_IF);
  221.      case THEN:   return(Y_THEN);
  222.      case STOP:   return(Y_STOP);
  223.      case CONT:   return(Y_CONT);
  224.      case GOSUB:  return(Y_GOSUB);
  225.      case RETURN: return(Y_RETURN);
  226.      case DELETE: return(Y_DELETE);
  227.      case DIM:    return(Y_DIM);
  228.      case FOR:    return(Y_FOR);
  229.      case TO:     return(Y_TO);
  230.      case STEP:   return(Y_STEP);
  231.      case NEXT:   return(Y_NEXT);
  232.      case NEW:    return(Y_NEW);
  233.      case RUN:    return(Y_RUN);
  234.          case RND:    return(Y_RND);
  235.      case FOPEN:  return(Y_FOPEN);
  236.      case FPRINT: return(Y_FPRINT);
  237.      case V0:     return(Y_V0);
  238.      case VX:     return(Y_VX);
  239.      case VY:     return(Y_VY);
  240.      case VZ:     return(Y_VZ);
  241.      case PLANE:  return(Y_PLANE);
  242.      case BIT:    return(Y_BIT);
  243.      case BOUND:  return(Y_BOUND);
  244.      case TEX:    return(Y_TEX);
  245.      case TRANSFORM: return(Y_TRANSFORM);
  246.      case B_FKT:  fkt_id=VALTOKEN((unsigned char)*(clines+(clinep++)));
  247.               return(Y_FKT);
  248.      case B_VAL:  n1=Y_VAL; goto la_val2;
  249.      case B_NUM:  n1=Y_NUM; goto la_val2;
  250.      case B_VEC:  n1=Y_VEC; goto la_val2;
  251.      case B_STR:  n1=Y_STR; goto la_val2;
  252.  
  253.      la_val2:     s=clines+clinep;
  254.               n=GET4HEX(s); clinep+=4;
  255.               if((tnode=t_symfind(n))==(T_NODE *)NULL)
  256.             t_error(msg,-1);
  257.               yylval.t=tnode;
  258.               return(n1);
  259.  
  260.      case B_OBJ:  s=clines+clinep;
  261.               n=GET4HEX(s); clinep+=4;
  262.               if((tnode=t_symfind(n))==(T_NODE *)NULL)
  263.             t_error(msg,-1);
  264.               yylval.p=tnode->p;
  265.               return(Y_OBJ);
  266.  
  267.     } /* switch */
  268.     else
  269.       switch(c)
  270.     {
  271.      case 0:  return(EOF);
  272.      default: return(c);
  273.     }
  274.    } /* if transl_flag else */
  275.  
  276.  return(EOF);
  277. }
  278.  
  279.